Restore the array

Time: O(NLogK); Space: O(LogK); hard

A program was supposed to print an array of integers. The program forgot to print whitespaces and the array is printed as a string of digits and all we know is that all integers in the array were in the range [1, k] and there are no leading zeros in the array.

Given the string s and the integer k. There can be multiple ways to restore the array.

Return the number of possible array that can be printed as a string s using the mentioned program.

The number of ways could be very large so return it modulo 10^9 + 7

Example 1:

Input: s = “1000”, k = 10000

Output: 1

Explanation:

  • The only possible array is [1000]

Example 2:

Input: s = “1000”, k = 10

Output: 0

Explanation:

  • There cannot be an array that was printed this way and has all integer >= 1 and <= 10.

Example 3:

Input: s = “1317”, k = 2000

Output: 8

Explanation:

  • Possible arrays are [1317],[131,7],[13,17],[1,317],[13,1,7],[1,31,7],[1,3,17],[1,3,1,7]

Example 4:

Input: s = “2020”, k = 30

Output: 1

Explanation:

  • The only possible array is [20,20]. [2020] is invalid because 2020 > 30. [2,020] is ivalid because 020 contains leading zeros.

Example 5:

Input: s = “1234567890”, k = 90

Output: 34

Constraints:

  • 1 <= len(s) <= 10^5.

  • s consists of only digits and doesn’t contain leading zeros.

  • 1 <= k <= 10^9.

Hints:

  1. Use dynamic programming. Build an array dp where dp[i] is the number of ways you can divide the string starting from index i to the end.

  2. Keep in mind that the answer is modulo 10^9 + 7 and take the mod for each operation.

1. Dynamic programming [O(NLogK), O(LogK)]

[1]:

class Solution1(object):
    """
    Time: O(NLogK)
    Space: O(LogK)
    """
    def numberOfArrays(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: int
        """
        MOD = 10**9 + 7
        klen = len(str(k))
        dp = [0]*(klen+1)
        dp[len(s)%len(dp)] = 1

        for i in reversed(range(len(s))):
            dp[i%len(dp)] = 0
            if s[i] == '0':
                continue

            curr = 0
            for j in range(i, min(i+klen, len(s))):
                curr = 10*curr + int(s[j])
                if curr > k:
                    break
                dp[i%len(dp)] = (dp[i%len(dp)] + dp[(j+1)%len(dp)])%MOD

        return dp[0]

[3]:

sol = Solution1()

s = "1000"
k = 10000
assert sol.numberOfArrays(s, k) == 1

s = "1000"
k = 10
assert sol.numberOfArrays(s, k) == 0

s = "1317"
k = 2000
assert sol.numberOfArrays(s, k) == 8

s = "2020"
k = 30
assert sol.numberOfArrays(s, k) == 1

s = "1234567890"
k = 90
assert sol.numberOfArrays(s, k) == 34